#include<bits/stdc++.h>
#include<iostream>
using namespace std;

#if 0
// class A
// {
// public:
//     A(int*& _a)
//         :a(_a)
//     {}
// private:
//     int*& a;
//     const int b = 2;
//     static const char c;
//     static double* d;
// };
// double* A::d = nullptr;
// int main()
// {

//     return 0;
// }

#if 0
//0328
#include<iostream>
#include<string>
#include<vector>
using namespace std;
int main()
{
    int n;
    cin >> n;
    vector<string> v(n);
    for(int i = 0;i<n;i++)
        cin >> v[i];
    //定义两个变量  然后遍历字符串比较是否是字典序排序 or 按长度排序
    //按长度排序:则 v[i].size() > v[i-1].size()
    //按字典序排序:则v[i] > v[i-1]
    bool flag1 = true;
    bool flag2 = true;
    for(int i = 1;i<n;i++)
    {
        if(v[i-1].size() > v[i].size())
        {
            flag1 = false;
            break;
        }
    }
    for(int i = 1;i<n;i++)
    {
        if(v[i-1] > v[i])
        {
            flag2 = false;
            break;
        }
    }
    if(flag1 && flag2)
        cout <<"both" << endl;
    else if(flag1)
        cout << "lengths" << endl;
    else if(flag2)
        cout <<"lexicographically"<<endl;
    else 
        cout <<"none" << endl;
        
    return 0;
}

#endif

#if 0
#include<iostream>
using namespace std;
int gcd(int a,int b)
{
    return b ? gcd(b,a % b) : a;
}
int main()
{
    int a,b;
    cin >> a >> b;
//     //最小公倍数:最小也是二者之中最大的值
//     int maxVal = max(a,b);
//     //从maxVal不断往上递增,找到第一个能同时整除a和b的数
//     while(1)
//     {
//         if(maxVal % a == 0 && maxVal % b == 0)
//         {
//             cout <<maxVal << endl;
//             break;
//         }
//         maxVal++;
//     }
    cout << a*b  / gcd(a,b) << endl;
    return 0;
}

//0328
#include<iostream>
using namespace std;
//目标:左上角走到右下角  转换思路:从右下角走到左上角

int PathSum(int n,int m)
{
    if(n == 0 || m == 0) //只能往左/右走
        return 1; 
    //往上走 和 往左走的方法数累加
    return PathSum(n-1,m) + PathSum(n, m-1);
}
int main()
{
    int n,m;
    cin >> n >> m;
    cout << PathSum(n,m);
    return 0;
}

class UnusualAdd {
public:
    int addAB(int A, int B) {
        // write code here
        //异或:无进位相加  &:得到进位信息 
        return B == 0 ? A : addAB(A^B, (A&B) << 1);
    }
};
#endif



#if 0
int main()
{
    int* p =nullptr;
    cout << sizeof(*p) << endl; //sizeof内部的表达式不参与真实运算,不会访问对应的空间
    return 0;
}
#endif

#if 0
//0331
class LCA {
public:
    int getLCA(int a, int b) {
        // write code here
        //结束条件:二者编号相同
        while(a!=b)
        {
            //大的编号的那个孩子除2 
            a>b?a/=2:b/=2;
        }
        return a;
    }
};


#include<iostream>
using namespace std;
int main()
{
    int num;
    //多组输入
    while(cin>>num)
    {
        int count = 0;
        int max_count = 0;
        for(int i = 0;i<32;i++)
        {
            //判断num的每一位是不是1,用1左移进行判断!
            if(num&(1<<i))
            {
                count++;
                max_count = max(max_count,count);//更新max_count
            }
            else
            {
                count = 0;    
            }
        }
        cout<<max_count<<endl;
    }
    return 0;
}

#endif

//0401
// class A 
// {
// public:
//     int _a = 10;
//     double _d = 20.0;
// };
// int main()
// {
//     A* a1 = new A;
//     cout << a1->_a << " " << a1->_d << endl;

//     A* a2 = new A();
//     cout << a2->_a << " " << a2->_d << endl;
//     return 0;
// }

//class A
//{
//public:
//	virtual void func()
//	{}
//};
//class B :public A
//{
//public:
//	int _b = 10;
//};
//void Func(A* pa)
//{
//	B* p = dynamic_cast<B*>(pa);
//	if (p == NULL)
//	{
//		cout << "转换失败" << endl;
//	}
//	else
//	{
//		cout << p->_b << endl;
//		p->_b++;
//	}
//}
//int main()
//{
//	A a;
//	B b;
//	Func(&a);
//	Func(&b);
//	return 0;
//}

#if 0
class BinInsert {
public:
    int binInsert(int n, int m, int j, int i) {
        // write code here
        return (m << j) | n;
    }
};


#include<bits/stdc++.h>
using namespace std;
bool isPrime(int n)
{
      for(int i = 2;i<=sqrt(n);i++)
                if(n%i == 0)
                              return false;
          
          return true;

}
int main()
{
      int n;
          cin >> n;
              int left = n / 2,right = left;
                  //必须要二者都是素数
                  //    while(!isPrime(left) || !isPrime(right))
                  //        {
                  //                left--;
                  //                        right++;
                  //                            }
                  //                                cout << left << endl <<right << endl;
                  //                                    return 0;
                  //                                    }
                  //
                  //        }
}
#endif

//0402
#if 0
int main()
{
    int* p = (int*)malloc(10*sizeof(int));
    cout << p << " " << *p << endl;

    int* tmp = (int*)realloc(p,2*sizeof(int));
    p = tmp;
    cout << p << " " << *p << endl;

    return 0;
}

#include<iostream>
#include<string>
#include<vector>
using namespace std;
int main()
{
    string str;
    //多组输入
    while(getline(cin,str))    //因为字符串要读取空格,使用getline
    {
        vector<string> v;//存放分解后的参数
        bool flag = false;//标志是否遇到了”,初始化为false,没有遇到
        string tmp;//保存临时分解的参数
        //遍历字符串
        for(int i = 0;i<str.size();i++)
        {
            //case1:遇到"
             if(str[i] == '"')
             {
                 //第一次遇到"的起始位置,flag置为true
                 //第二次遇到"的末尾时,flag置为false
                 //形成了一个闭环,遇到起始位置的"->false,遇到末尾位置的"->true
                 flag = !flag;//将flag取反
             }
            //case2:遇到空格 && 没有遇到"
            //如果遇到了"  ->则该里面的空格不能作为分割
            else if(str[i] == ' ' && !flag)
            {
                v.push_back(tmp);
                tmp.clear();//记得要清空tmp,为下一轮作准备
            }
            //case3:其它字符
            else
            {
                tmp+=str[i];
            }
        }
        //注意:最后一个参数没有空格,最后跳出循环,该参数并没有压入容器中
        //我们要手动压入
        v.push_back(tmp);
        
        
        //输出结果
        cout<<v.size()<<endl;
        for(auto x : v)
        {
            cout<<x<<endl;
        }
    }
    return 0;
}
#endif

//0403
// #include<memory.h> //C++库的智能指针都定义在这个库当中
// class A
// {};
// int main()
// {
//   shared_ptr<A> p(new A);
//   shared_ptr<A> p2(new A[10]);     
//   shared_ptr<FILE> p3(fopen("./Makefile","r"));
//   return 0;
// }


//0404
// #include<bits/stdc++.h>
// using namespace std;
// size_t CountBit(int n)
// {
//     int count = 0;
//     while(n)
//     {
//         n -= n&(-n);
//         count++;
//     }
//     return count;
// }
// int main()
// {
//     int n;
//     while(cin >> n)
//     {
//         cout << CountBit(n) << endl;
//     }
//     return 0;
// }

//0405
// class Solution {
// public:
//     void getResult(int n,vector<int>& record,vector<vector<string>>& result)
//     {
//         vector<string> res;
//         for(int i = 0;i<n;i++)
//         {
//             string ans(n,'.');
//             ans[record[i]] = 'Q';
//             res.push_back(ans);
//         }
//         result.push_back(res);
//     }
//     bool check(vector<int>& record,int i,int j) //当前皇后放在第i行第j列会不会和其它皇后产生冲突
//     {
//         //和前i-1行的皇后判断
//         for(int k = 0;k<i;k++)
//         {
//             //第k行的皇后放在record[k]列
//             if(record[k] == j || abs(i - k) == abs(j - record[k]))
//                 return false;
//         }
//         return true;
//     }
//     void process(vector<int>& record,int n,int index,vector<vector<string>>& result)
//     {
//         if(index == n) //当前是一种合法的方法
//         {
//             getResult(n,record,result);
//             return ;
//         }
//         //当前index行的皇后应该放在哪一列
//         for(int i = 0;i<n;i++)
//         {
//             if(check(record,index,i))
//             {
//                 record[index] = i;
//                 process(record,n,index+1,result);
//             }
//         }
//     }
//     vector<vector<string>> solveNQueens(int n) {
//         vector<vector<string>> result;
//         vector<int> record(n,0);
//         process(record,n,0,result);
//         return result;
//     }
// };


//0406
// class Solution {
// public:
//     vector<int> maxSlidingWindow(vector<int>& nums, int k) {
//         vector<int> ans;
//         deque<int> maxq;//最大值更新结构
//         for(int index = 0;index<nums.size();index++)
//         {
//             while(!maxq.empty() && nums[index] >= nums[maxq.back()])
//                 maxq.pop_back();
//             maxq.push_back(index);

//             if(maxq.front() == index -k)
//                 maxq.pop_front();
//             if(index >= k-1)
//                 ans.push_back(nums[maxq.front()]);
//         }
//         return ans;
//     }
// };

// //暴力做法
// class Solution {
// public:
//     //暴力做法
//     vector<int> maxSlidingWindow(vector<int>& nums, int k) {
//         //最初的窗口范围:[L,R]
//         int L = 0;
//         int R = k-1;
//         vector<int> ans;
//         int n = nums.size();
//         //每次L++,R++就到了下一个窗口的位置
//         while(R < n)
//         {
//             //遍历找当前窗口[L,R]的最大值
//             int maxVal = nums[L]; //不建议写成0，放着全是负数
//             for(int i = L+1;i<=R;i++)
//             {
//                 maxVal = max(nums[i],maxVal);
//             }
//             ans.push_back(maxVal);
//             //来到下一个窗口
//             L++,R++;
//         }
//         return ans;
//     }   
// };

//0407

// //674.https://leetcode.cn/problems/longest-continuous-increasing-subsequence/
// class Solution {
// public:
//     int findLengthOfLCIS(vector<int>& nums) {
//         vector<int> dp(nums.size(),1);//dp[i]:以i位置为结尾的最长连续递增序列的长度
//         int res   = 1;
//         for(int i = 1;i<nums.size();i++)
//         {
//             if(nums[i] > nums[i-1])
//                 dp[i] = dp[i-1] + 1;
//             res = max(res,dp[i]);
//         }
//         return res;
//     }
// };


//0410
#include<bits/stdc++.h>
using namespace std;
int main()
{
    int empty;
    while(cin >> empty)
    {
        if(empty == 0)
            break;
        int sum = empty / 3;
        int now = empty / 3 + empty % 3;
        while(now >= 3)
        {
            sum += now / 3;
            now = now /3 + now % 3;
        }
        if(now == 2)
            sum+= 1;
        cout << sum << endl;
    }
    return 0;
}



// //https://www.nowcoder.com/practice/cf24906056f4488c9ddb132f317e03bc 迷宫问题

// #include<bits/stdc++.h>
// using namespace std;

// struct Pos
// {
//     int x;
//     int y;
//     Pos(int a, int b)
//         :x(a),y(b)
//         {}
// };
// stack<Pos> pathStack;
// void PrintPath()
// {
//     stack<Pos> reverseStack;
//     while(!pathStack.empty())
//     {
//         reverseStack.push(pathStack.top());
//         pathStack.pop();
//     }
//     while(!reverseStack.empty())
//     {
//         Pos pos = reverseStack.top();
//         printf("(%d,%d)\n",pos.x,pos.y);
//         reverseStack.pop();
//     }
// }
// //判断合法路径
// bool IsPass(vector<vector<int>>& vv, Pos pos)
// {
//     int n = vv.size();
//     int m = vv[0].size();
//     if(pos.x >=0 && pos.x < n && pos.y >=0 && pos.y < m && vv[pos.x][pos.y] == 0)
//         return true;
//     return false;
// }
// //右走 || 下走
// bool FindPath(vector<vector<int>>& vv,Pos pos)
// {
//     int endX = vv.size()-1;
//     int endY = vv[0].size()-1;
//     pathStack.push(pos);
//     vv[pos.x][pos.y] = 2;//表示当前位置已经走过了
//     if(pos.x == endX && pos.y == endY)
//     {
//         return true;
//     }
//     Pos right = {pos.x,pos.y+1};
//     Pos down = {pos.x+1,pos.y};
//     Pos left = {pos.x-1,pos.y};
//     Pos up = {pos.x,pos.y-1};
//     if(IsPass(vv,down))
//     {
//          if(FindPath(vv,down))
//             return true;
//     }
//     if(IsPass(vv,left))
//     {
//         if(FindPath(vv,left))
//             return true;
//     }
//     if(IsPass(vv,right))
//     {
//          if(FindPath(vv,right))
//             return true;
//     }
//     if(IsPass(vv,up))
//     {
//         if(FindPath(vv,up))
//             return true;
//     }
//     pathStack.pop();
//     return false;
// }
// int main()
// {
//     int n,m;
//     cin >> n >> m;
//     vector<vector<int>> vv(n,vector<int>(m,0));
//     for(int i = 0;i<n;i++)
//     {
//         for(int j = 0;j<m;j++)
//             cin >> vv[i][j];
//     }
//     Pos start = {0,0};
//     if(FindPath(vv,start))
//     {
//         PrintPath();
//     }
//     return 0;
// }


// //https://www.nowcoder.com/questionTerminal/e2422543519249f292d8435394ab82fe

// // write your code here cpp
// #include<bits/stdc++.h>
// using namespace std;
// //把每一位进行相加
// typedef long long LL;
// LL GetVal(LL n)
// {
//     LL sum = 0;
//     while(n)
//     {
//         sum += n % 10;
//         n /= 10;
//     }
//     return sum;
// }
// int main()
// {
// //     LL n;
// //     while(cin >> n)
// //     {
// //         LL ret = GetVal(n);
// //         while(ret > 9)
// //             ret = GetVal(ret);
// //         cout << ret << endl;
// //     }
//     string str;
//     while(cin >> str)
//     {
//         LL n = 0;//每一位的和
//         for(int i = 0;i<str.size();i++)
//             n += str[i] - '0';
        
//          LL ret = GetVal(n);
//         while(ret > 9)
//             ret = GetVal(ret);
//         cout << ret << endl;
//     }
//     return 0;
// }


// //0420
// class LRUCache {
// public:
//     LRUCache(int capacity) {
//         _capacity = capacity;
//     }
    
//     int get(int key) {
//         auto ret = um.find(key);
//         if(ret == um.end())
//         {
//             return -1;
//         }
//         else 
//         {
//             IteratorList it = ret->second;
//             lt.splice(lt.begin(),lt,it);
//             return it->second;   
//         }
//     }
    
//     void put(int key, int value) {
//         auto ret = um.find(key);
//         if(ret == um.end()) //新插入
//         {
//             //检查容量是否满了
//             if(_capacity == um.size())
//             {
//                 pair<int,int> back = lt.back();
//                 lt.pop_back();
//                 um.erase(back.first);
//             }
//             lt.push_front({key,value});
//             um[key] = lt.begin();
//         }
//         else  //更改值
//         {
//             IteratorList it = ret->second;
//             it->second = value;
//             lt.splice(lt.begin(),lt,it);
//         }
//     }
//     typedef list<pair<int,int>>::iterator IteratorList;
// private:
//     int _capacity;
//     list<pair<int,int>> lt;
//     unordered_map<int,IteratorList> um;
// };


// //https://leetcode.cn/problems/merge-intervals/  56-合并区间

// class Solution {
// public:
//     vector<vector<int>> merge(vector<vector<int>>& a) {
//         //根据起始位置排升序
//         auto cmp = [](const vector<int>& l,const vector<int>& r){
//             //如果起始位置相同,则按末尾位置排升序
//             if(l[0] == r[0])
//                 return l[1] < r[1];
//             else 
//                 return l[0] < r[0];
//         };
//         sort(a.begin(),a.end(),cmp);
//         vector<vector<int>> res;
//         int start = a[0][0],end = a[0][1];
//         for(int i = 1;i<a.size();i++)
//         {
//             if(end >= a[i][0])
//             {
//                 end = max(end,a[i][1]);
//             }
//             else 
//             {
//                 res.push_back(vector<int>{start,end});  
//                 start = a[i][0],end = a[i][1];
//             }
//         }
//         res.push_back(vector<int>{start,end});    
//         return res;
//     }
// };

#endif


